// import router from './router'
// import store from './store'
// import { Message } from 'element-ui'
// import NProgress from 'nprogress' // progress bar
// import 'nprogress/nprogress.css' // progress bar style
// import { getToken } from '@/utils/auth' // get token from cookie
// import getPageTitle from '@/utils/get-page-title'

// NProgress.configure({ showSpinner: false }) // NProgress Configuration

// const whiteList = ['/login'] // no redirect whitelist
// let isAddRoutes = false // 添加的标志位，防止死循环

// /**
//  * 处理后端返回的路由数据，确保Layout类型的路由有正确的children结构
//  * @param {Array} routes 原始路由数组
//  * @returns {Array} 处理后的路由数组
//  */
// function processBackendRoutes(routes) {
//   if (!routes || !Array.isArray(routes)) {
//     return []
//   }

//   return routes.map(route => {
//     // 创建新对象，避免修改原对象
//     const newRoute = { ...route }

//     // 如果是Layout类型的组件且没有children或children为空数组或null
//     if (
//       (newRoute.component === 'Layout') &&
//       (!newRoute.children || !newRoute.children.length || newRoute.children === null)
//     ) {
//       console.log(`为路由 ${newRoute.path} 添加默认子路由`)

//       // 特殊处理userinfo路由
//       if (newRoute.path === '/userinfo') {
//         newRoute.children = [{
//           path: 'index',
//           name: 'userinfo',
//           component: 'userInfo/index',
//           meta: {
//             title: newRoute.meta ? newRoute.meta.title : '个人信息',
//             icon: newRoute.meta ? newRoute.meta.icon : 'el-icon-user-solid'
//           }
//         }]
//       } else {
//         // 创建默认的子路由
//         const routePath = newRoute.path.replace(/^\//, '')
//         newRoute.children = [{
//           path: 'index',
//           name: newRoute.name ? `${newRoute.name}-detail` : 'index',
//           component: `${routePath}/index`,
//           meta: {
//             title: newRoute.meta ? newRoute.meta.title : (newRoute.name || ''),
//             icon: newRoute.meta ? newRoute.meta.icon : ''
//           }
//         }]
//       }

//       // 添加重定向
//       newRoute.redirect = `${newRoute.path}/index`
//     } else if (newRoute.children && newRoute.children.length) {
//       // 递归处理子路由
//       newRoute.children = processBackendRoutes(newRoute.children)
//     }

//     return newRoute
//   })
// }

// router.beforeEach(async (to, from, next) => {
//   // start progress bar
//   NProgress.start()

//   // set page title
//   document.title = getPageTitle(to.meta.title)

//   // determine whether the user has logged in
//   const hasToken = getToken()

//   if (hasToken) {
//     if (to.path === '/login') {
//       // 如果已登录，重定向到首页
//       next({ path: '/' })
//       NProgress.done()
//     } else {
//       const hasGetUserInfo = store.getters.username
//       if (hasGetUserInfo && isAddRoutes) {
//         next()
//       } else {
//         try {

//           // 获取用户信息
//           const userInfo = await store.dispatch('user/getInfo')
//           console.log('获取到的用户信息:', userInfo)

//           // 获取菜单数据
//           const menus = store.getters.menus
//           console.log('获取到的菜单数据:', menus)

//           // 更灵活地处理菜单数据，支持多种数据结构
//           let asyncRoutes = []
//           if (menus) {
//             console.log('菜单数据类型:', Object.prototype.toString.call(menus))

//             // 尝试转换 Vue 响应式对象为普通对象
//             let rawMenus = menus
//             if (menus.__ob__) {
//               console.log('检测到 Vue 响应式对象，尝试获取原始数据')
//               try {
//                 rawMenus = JSON.parse(JSON.stringify(menus))
//                 console.log('转换后的原始菜单数据:', rawMenus)
//               } catch (e) {
//                 console.error('转换响应式对象失败:', e)
//               }
//             }

//             // 处理不同的数据结构
//             if (rawMenus.map && rawMenus.map.routers && Array.isArray(rawMenus.map.routers)) {
//               // 结构 1: { map: { routers: [...] } }
//               asyncRoutes = rawMenus.map.routers
//               console.log('使用 map.routers 数组数据，长度:', asyncRoutes.length)
//             } else if (Array.isArray(rawMenus)) {
//               // 结构 2: 直接是路由数组
//               asyncRoutes = rawMenus
//               console.log('使用数组数据，长度:', asyncRoutes.length)
//             } else if (rawMenus.routers && Array.isArray(rawMenus.routers)) {
//               // 结构 3: { routers: [...] }
//               asyncRoutes = rawMenus.routers
//               console.log('使用 routers 数组数据，长度:', asyncRoutes.length)
//             } else if (rawMenus.menuList && Array.isArray(rawMenus.menuList)) {
//               // 结构 4: { menuList: [...] }
//               asyncRoutes = rawMenus.menuList.map(item => {
//                 return {
//                   path: item.path || '',
//                   component: item.component || 'Layout',
//                   name: item.name || '',
//                   meta: {
//                     title: item.name || '',
//                     icon: item.icon || ''
//                   },
//                   children: item.children || null
//                 }
//               })
//               console.log('使用转换后的 menuList 数据，长度:', asyncRoutes.length)
//             } else {
//               console.warn('菜单数据结构不符合预期，尝试其他方式提取')
//             }
//           }

//           console.log('处理前的路由数据:', asyncRoutes)

//           // 处理后端返回的路由数据，确保Layout类型的路由有正确的children结构
//           asyncRoutes = processBackendRoutes(asyncRoutes)

//           console.log('处理后的路由数据:', asyncRoutes)

//           // 如果没有获取到有效的路由，使用默认路由
//           if (!asyncRoutes || asyncRoutes.length === 0) {
//             console.warn('未获取到有效的路由数据，使用默认路由')
//             asyncRoutes = []
//           }

//           if (!isAddRoutes) {
//             // 使用 permission 模块生成路由
//             const accessRoutes = await store.dispatch('permission/generateRoutes', asyncRoutes)

//             // 添加动态路由
//             router.addRoutes(accessRoutes)

//             // 添加 404 路由
//             router.addRoutes([{ path: '*', redirect: '/404', hidden: true }])

//             isAddRoutes = true

//             // 使用 replace 进行跳转，避免重复导航
//             next({ ...to, replace: true })
//           } else {
//             next()
//           }
//         } catch (error) {
//           // remove token and go to login page to re-login
//           await store.dispatch('user/resetToken')
//           Message.error(error || '出现错误，请重新登录')
//           next(`/login?redirect=${to.path}`)
//           NProgress.done()
//         }
//       }
//     }
//   } else {
//     /* has no token*/

//     if (whiteList.indexOf(to.path) !== -1) {
//       // in the free login whitelist, go directly
//       next()
//     } else {
//       // other pages that do not have permission to access are redirected to the login page.
//       next(`/login?redirect=${to.path}`)
//       NProgress.done()
//     }
//   }
// })

// router.afterEach(() => {
//   // finish progress bar
//   NProgress.done()
// })

import router from "./router";
import store from "./store";
import { getToken } from "@/utils/auth";
import { Message } from "element-ui";
import NProgress from "nprogress";
import "nprogress/nprogress.css";
import getPageTitle from "@/utils/get-page-title";

NProgress.configure({ showSpinner: false });

const whiteList = ["/login"]; // 不重定向白名单
let isAddRoutes = false; // 添加的标志位，防止死循环
// 修改重置路由状态方法，不再调用resetRouter
export function resetRouteState() {
  // 只重置标志位
  isAddRoutes = false;
}
/**
 * 处理后端返回的路由数据，确保Layout类型的路由有正确的children结构
 * @param {Array} routes 原始路由数组
 * @returns {Array} 处理后的路由数组
 */
function processBackendRoutes(routes) {
  if (!routes || !Array.isArray(routes)) {
    return [];
  }

  return routes.map((route) => {
    // 创建新对象，避免修改原对象
    const newRoute = { ...route };

    // 如果是Layout类型的组件且没有children或children为空数组或null
    if (
      newRoute.component === "Layout" &&
      (!newRoute.children ||
        !newRoute.children.length ||
        newRoute.children === null)
    ) {
      // 特殊处理userinfo路由
      if (newRoute.path === "/userinfo") {
        newRoute.children = [
          {
            path: "index",
            name: "userinfo",
            component: "userInfo/index",
            meta: {
              title: newRoute.meta ? newRoute.meta.title : "个人信息",
              icon: newRoute.meta ? newRoute.meta.icon : "el-icon-user-solid",
            },
          },
        ];
      } else if (newRoute.path === "/log") {
        newRoute.children = [
          {
            path: "index",
            name: "log",
            component: "logback/index",
            meta: {
              title: newRoute.meta ? newRoute.meta.title : "日志管理",
              icon: newRoute.meta ? newRoute.meta.icon : "el-icon-document",
            },
          },
        ];
      } else {
        // 创建默认的子路由
        const routePath = newRoute.path.replace(/^\//, "");
        newRoute.children = [
          {
            path: "index",
            name: newRoute.name ? `${newRoute.name}-detail` : "index",
            component: `${routePath}/index`,
            meta: {
              title: newRoute.meta ? newRoute.meta.title : newRoute.name || "",
              icon: newRoute.meta ? newRoute.meta.icon : "",
            },
          },
        ];
      }

      // 添加重定向
      newRoute.redirect = `${newRoute.path}/index`;
    } else if (newRoute.children && newRoute.children.length) {
      // 递归处理子路由
      newRoute.children = processBackendRoutes(newRoute.children);
    }

    return newRoute;
  });
}

router.beforeEach(async (to, from, next) => {
  NProgress.start();
  document.title = getPageTitle(to.meta.title);

  const hasToken = getToken();

  if (hasToken) {
    if (to.path === "/login") {
      next({ path: "/" });
      NProgress.done();
    } else {
      const hasGetUserInfo = store.getters.username;

      if (hasGetUserInfo && isAddRoutes) {
        next();
      } else {
        try {
          // 获取用户信息
          const userInfo = await store.dispatch("user/getInfo");
          const menus = store.getters.menus;

          // 更灵活地处理菜单数据，支持多种数据结构
          let asyncRoutes = [];
          if (menus) {
            // 尝试转换 Vue 响应式对象为普通对象
            let rawMenus = menus;
            if (menus.__ob__) {
              try {
                rawMenus = JSON.parse(JSON.stringify(menus));
              } catch (e) {}
            }

            // 处理不同的数据结构
            if (
              rawMenus.map &&
              rawMenus.map.routers &&
              Array.isArray(rawMenus.map.routers)
            ) {
              // 结构 1: { map: { routers: [...] } }
              asyncRoutes = rawMenus.map.routers;
            } else if (Array.isArray(rawMenus)) {
              // 结构 2: 直接是路由数组
              asyncRoutes = rawMenus;
            } else if (rawMenus.routers && Array.isArray(rawMenus.routers)) {
              // 结构 3: { routers: [...] }
              asyncRoutes = rawMenus.routers;
            } else if (rawMenus.menuList && Array.isArray(rawMenus.menuList)) {
              // 结构 4: { menuList: [...] }
              asyncRoutes = rawMenus.menuList.map((item) => {
                return {
                  path: item.path || "",
                  component: item.component || "Layout",
                  name: item.name || "",
                  meta: {
                    title: item.name || "",
                    icon: item.icon || "",
                  },
                  children: item.children || null,
                };
              });
            } else {
            }
          }

          // 处理后端返回的路由数据，确保Layout类型的路由有正确的children结构
          asyncRoutes = processBackendRoutes(asyncRoutes);

          // 如果没有获取到有效的路由，使用默认路由
          if (!asyncRoutes || asyncRoutes.length === 0) {
            asyncRoutes = [];
          }
          if (!isAddRoutes) {
            // 使用 permission 模块生成路由
            const accessRoutes = await store.dispatch(
              "permission/generateRoutes",
              asyncRoutes
            );

            // 添加动态路由
            router.addRoutes(accessRoutes);

            // 添加 404 路由
            router.addRoutes([{ path: "*", redirect: "/404", hidden: true }]);

            isAddRoutes = true;

            // 简化跳转逻辑，如果是从登录页来的，始终跳转到首页
            if (from.path === "/login") {
              next({ path: "/dashboard", replace: true });
            } else {
              // 否则跳转到当前请求的页面
              next({ ...to, replace: true });
            }
          } else {
            next();
          }
        } catch (error) {
          // 重置 token
          await store.dispatch("user/resetToken");
          Message.error(error?.message || "系统错误，请重新登录");
          next(`/login?redirect=${to.path}`);
          NProgress.done();
        }
      }
    }
  } else {
    // 无 token，白名单放行
    if (whiteList.indexOf(to.path) !== -1) {
      next();
    } else {
      next(`/login?redirect=${to.path}`);
      NProgress.done();
    }
  }
});

router.afterEach(() => {
  NProgress.done();
});
